import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test02 {
    public static void main(String[] args) {
        String sqlStr = "select id -- 完成 \n "
                + " ,CODE_ID,CODE_NAME from \\code_table where CODE_NAME='--lii'  --去掉\n"
        + "--and day <= '2022-07-07'";
        Pattern p = Pattern.compile("(?ms)('(?:''|[^'])*')|(--.*?$)|/\\*.*?\\*/|#.*?$|");
        Matcher matcher = p.matcher(sqlStr);

        while (matcher.find()){
            String attributeName = matcher.group(0);
            String attributeValue = matcher.group(1);
            System.out.println("attributeName->"+attributeName +",attributeValue->"+attributeValue );
        }
        Matcher presult2 = p.matcher(sqlStr);
        String presult = p.matcher(sqlStr).replaceAll("$1$2");

        String str = "''abc''";
        Pattern p1= Pattern.compile("('(?:''|[^'])*')");
        Matcher matcher1 = p1.matcher(str);
        System.out.println(matcher1.find());

        System.out.println(Singleton.getInstance() == Singleton.getInstance());
        System.out.println(Singleton2.getInstance() == Singleton2.getInstance());
        System.out.println(Singleton3.getInstance() == Singleton3.getInstance());
        System.out.println(Singleton4.getInstance() == Singleton4.getInstance());
        System.out.println(Singleton5.getInstance() == Singleton5.getInstance());
        System.out.println(Singleton6.INSTANCE == Singleton6.INSTANCE);
        System.out.println(Singleton7.getInstance() == Singleton7.getInstance());
    }

    /**
     * 单例模式，饿汉式
     */
    public static class Singleton{
        private final static Singleton INSTANCE = new Singleton();
        private Singleton(){

        }
        public static Singleton getInstance(){
            return INSTANCE;
        }
    }

    /**
     * 懒汉式，线程不安全
     */
    public static class Singleton2{
        private  static Singleton2 instance = null;
        private Singleton2(){

        }
        public static Singleton2 getInstance(){
            if (instance==null){
                instance = new Singleton2();
            }
            return instance;
        }
    }

    /**
     * 懒汉式，线程安全，多线程情况下效率不高
     */
    public static class Singleton3{
        private static Singleton3 instance = null;
        private Singleton3(){

        }
        public static synchronized Singleton3 getInstance(){
            if (instance == null)
                instance = new Singleton3();
            return instance;
        }
    }

    /**
     * 懒汉式，线程安全
     */
    public static class Singleton4{
        private static Singleton4 instance =null;
        static {
            instance = new Singleton4();
        }
        private Singleton4(){

        }
        public static Singleton4 getInstance(){
            return instance;
        }
    }

    /**
     * 使用静态内部类的方式，线程安全推荐使用
     */
    public static class Singleton5{
        private final static class SingletonHolder{
            private final static Singleton5 instance = new Singleton5();
        }
        private Singleton5(){
        }
        public static Singleton5 getInstance(){
            return SingletonHolder.instance;
        }
    }


    /**
     * 静态内部类，使用枚举方式，线程安全【推荐】
     */
    public enum Singleton6 {
        INSTANCE;

        public void whateverMethod() {
        }
    }

    /**
     * 懒汉式，双重null判断，效率高且线程安全，推荐使用
     */
    public static class Singleton7{
        private volatile static Singleton7 instance = null;
        private Singleton7(){
        }
        public static Singleton7 getInstance(){
            if(instance == null){
                synchronized (Singleton7.class){
                    if(instance == null){
                        instance = new Singleton7();
                    }
                }
            }
            return  instance;
        }
    }

}
